home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / copy.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  9KB  |  416 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import types
  5. from copy_reg import dispatch_table
  6.  
  7. class Error(Exception):
  8.     pass
  9.  
  10. error = Error
  11.  
  12. try:
  13.     from org.python.core import PyStringMap
  14. except ImportError:
  15.     PyStringMap = None
  16.  
  17. __all__ = [
  18.     'Error',
  19.     'copy',
  20.     'deepcopy']
  21.  
  22. def copy(x):
  23.     cls = type(x)
  24.     copier = _copy_dispatch.get(cls)
  25.     if copier:
  26.         return copier(x)
  27.     
  28.     copier = getattr(cls, '__copy__', None)
  29.     if copier:
  30.         return copier(x)
  31.     
  32.     reductor = dispatch_table.get(cls)
  33.     if reductor:
  34.         rv = reductor(x)
  35.     else:
  36.         reductor = getattr(x, '__reduce_ex__', None)
  37.         if reductor:
  38.             rv = reductor(2)
  39.         else:
  40.             reductor = getattr(x, '__reduce__', None)
  41.             if reductor:
  42.                 rv = reductor()
  43.             else:
  44.                 raise Error('un(shallow)copyable object of type %s' % cls)
  45.     return _reconstruct(x, rv, 0)
  46.  
  47. _copy_dispatch = d = { }
  48.  
  49. def _copy_immutable(x):
  50.     return x
  51.  
  52. for t in (type(None), int, long, float, bool, str, tuple, frozenset, type, xrange, types.ClassType, types.BuiltinFunctionType, types.FunctionType):
  53.     d[t] = _copy_immutable
  54.  
  55. for name in ('ComplexType', 'UnicodeType', 'CodeType'):
  56.     t = getattr(types, name, None)
  57.     if t is not None:
  58.         d[t] = _copy_immutable
  59.         continue
  60.  
  61.  
  62. def _copy_with_constructor(x):
  63.     return type(x)(x)
  64.  
  65. for t in (list, dict, set):
  66.     d[t] = _copy_with_constructor
  67.  
  68.  
  69. def _copy_with_copy_method(x):
  70.     return x.copy()
  71.  
  72. if PyStringMap is not None:
  73.     d[PyStringMap] = _copy_with_copy_method
  74.  
  75.  
  76. def _copy_inst(x):
  77.     if hasattr(x, '__copy__'):
  78.         return x.__copy__()
  79.     
  80.     if hasattr(x, '__getinitargs__'):
  81.         args = x.__getinitargs__()
  82.         y = x.__class__(*args)
  83.     else:
  84.         y = _EmptyClass()
  85.         y.__class__ = x.__class__
  86.     if hasattr(x, '__getstate__'):
  87.         state = x.__getstate__()
  88.     else:
  89.         state = x.__dict__
  90.     if hasattr(y, '__setstate__'):
  91.         y.__setstate__(state)
  92.     else:
  93.         y.__dict__.update(state)
  94.     return y
  95.  
  96. d[types.InstanceType] = _copy_inst
  97. del d
  98.  
  99. def deepcopy(x, memo = None, _nil = []):
  100.     if memo is None:
  101.         memo = { }
  102.     
  103.     d = id(x)
  104.     y = memo.get(d, _nil)
  105.     if y is not _nil:
  106.         return y
  107.     
  108.     cls = type(x)
  109.     copier = _deepcopy_dispatch.get(cls)
  110.     if copier:
  111.         y = copier(x, memo)
  112.     else:
  113.         
  114.         try:
  115.             issc = issubclass(cls, type)
  116.         except TypeError:
  117.             issc = 0
  118.  
  119.         if issc:
  120.             y = _deepcopy_atomic(x, memo)
  121.         else:
  122.             copier = getattr(x, '__deepcopy__', None)
  123.             if copier:
  124.                 y = copier(memo)
  125.             else:
  126.                 reductor = dispatch_table.get(cls)
  127.                 if reductor:
  128.                     rv = reductor(x)
  129.                 else:
  130.                     reductor = getattr(x, '__reduce_ex__', None)
  131.                     if reductor:
  132.                         rv = reductor(2)
  133.                     else:
  134.                         reductor = getattr(x, '__reduce__', None)
  135.                         if reductor:
  136.                             rv = reductor()
  137.                         else:
  138.                             raise Error('un(deep)copyable object of type %s' % cls)
  139.                 y = _reconstruct(x, rv, 1, memo)
  140.     memo[d] = y
  141.     _keep_alive(x, memo)
  142.     return y
  143.  
  144. _deepcopy_dispatch = d = { }
  145.  
  146. def _deepcopy_atomic(x, memo):
  147.     return x
  148.  
  149. d[type(None)] = _deepcopy_atomic
  150. d[int] = _deepcopy_atomic
  151. d[long] = _deepcopy_atomic
  152. d[float] = _deepcopy_atomic
  153. d[bool] = _deepcopy_atomic
  154.  
  155. try:
  156.     d[complex] = _deepcopy_atomic
  157. except NameError:
  158.     pass
  159.  
  160. d[str] = _deepcopy_atomic
  161.  
  162. try:
  163.     d[unicode] = _deepcopy_atomic
  164. except NameError:
  165.     pass
  166.  
  167.  
  168. try:
  169.     d[types.CodeType] = _deepcopy_atomic
  170. except AttributeError:
  171.     pass
  172.  
  173. d[type] = _deepcopy_atomic
  174. d[xrange] = _deepcopy_atomic
  175. d[types.ClassType] = _deepcopy_atomic
  176. d[types.BuiltinFunctionType] = _deepcopy_atomic
  177. d[types.FunctionType] = _deepcopy_atomic
  178.  
  179. def _deepcopy_list(x, memo):
  180.     y = []
  181.     memo[id(x)] = y
  182.     for a in x:
  183.         y.append(deepcopy(a, memo))
  184.     
  185.     return y
  186.  
  187. d[list] = _deepcopy_list
  188.  
  189. def _deepcopy_tuple(x, memo):
  190.     y = []
  191.     for a in x:
  192.         y.append(deepcopy(a, memo))
  193.     
  194.     d = id(x)
  195.     
  196.     try:
  197.         return memo[d]
  198.     except KeyError:
  199.         pass
  200.  
  201.     for i in range(len(x)):
  202.         if x[i] is not y[i]:
  203.             y = tuple(y)
  204.             break
  205.             continue
  206.     else:
  207.         y = x
  208.     memo[d] = y
  209.     return y
  210.  
  211. d[tuple] = _deepcopy_tuple
  212.  
  213. def _deepcopy_dict(x, memo):
  214.     y = { }
  215.     memo[id(x)] = y
  216.     for key, value in x.iteritems():
  217.         y[deepcopy(key, memo)] = deepcopy(value, memo)
  218.     
  219.     return y
  220.  
  221. d[dict] = _deepcopy_dict
  222. if PyStringMap is not None:
  223.     d[PyStringMap] = _deepcopy_dict
  224.  
  225.  
  226. def _keep_alive(x, memo):
  227.     
  228.     try:
  229.         memo[id(memo)].append(x)
  230.     except KeyError:
  231.         memo[id(memo)] = [
  232.             x]
  233.  
  234.  
  235.  
  236. def _deepcopy_inst(x, memo):
  237.     if hasattr(x, '__deepcopy__'):
  238.         return x.__deepcopy__(memo)
  239.     
  240.     if hasattr(x, '__getinitargs__'):
  241.         args = x.__getinitargs__()
  242.         args = deepcopy(args, memo)
  243.         y = x.__class__(*args)
  244.     else:
  245.         y = _EmptyClass()
  246.         y.__class__ = x.__class__
  247.     memo[id(x)] = y
  248.     if hasattr(x, '__getstate__'):
  249.         state = x.__getstate__()
  250.     else:
  251.         state = x.__dict__
  252.     state = deepcopy(state, memo)
  253.     if hasattr(y, '__setstate__'):
  254.         y.__setstate__(state)
  255.     else:
  256.         y.__dict__.update(state)
  257.     return y
  258.  
  259. d[types.InstanceType] = _deepcopy_inst
  260.  
  261. def _reconstruct(x, info, deep, memo = None):
  262.     if isinstance(info, str):
  263.         return x
  264.     
  265.     if memo is None:
  266.         memo = { }
  267.     
  268.     n = len(info)
  269.     (callable, args) = info[:2]
  270.     if n > 2:
  271.         state = info[2]
  272.     else:
  273.         state = { }
  274.     if n > 3:
  275.         listiter = info[3]
  276.     else:
  277.         listiter = None
  278.     if n > 4:
  279.         dictiter = info[4]
  280.     else:
  281.         dictiter = None
  282.     if deep:
  283.         args = deepcopy(args, memo)
  284.     
  285.     y = callable(*args)
  286.     memo[id(x)] = y
  287.     if listiter is not None:
  288.         for item in listiter:
  289.             if deep:
  290.                 item = deepcopy(item, memo)
  291.             
  292.             y.append(item)
  293.         
  294.     
  295.     if dictiter is not None:
  296.         for key, value in dictiter:
  297.             if deep:
  298.                 key = deepcopy(key, memo)
  299.                 value = deepcopy(value, memo)
  300.             
  301.             y[key] = value
  302.         
  303.     
  304.     if state:
  305.         if deep:
  306.             state = deepcopy(state, memo)
  307.         
  308.         if hasattr(y, '__setstate__'):
  309.             y.__setstate__(state)
  310.         elif isinstance(state, tuple) and len(state) == 2:
  311.             (state, slotstate) = state
  312.         else:
  313.             slotstate = None
  314.         if state is not None:
  315.             y.__dict__.update(state)
  316.         
  317.         if slotstate is not None:
  318.             for key, value in slotstate.iteritems():
  319.                 setattr(y, key, value)
  320.             
  321.         
  322.     
  323.     return y
  324.  
  325. del d
  326. del types
  327.  
  328. class _EmptyClass:
  329.     pass
  330.  
  331.  
  332. def _test():
  333.     l = [
  334.         None,
  335.         1,
  336.         0x2L,
  337.         3.14,
  338.         'xyzzy',
  339.         (1, 0x2L),
  340.         [
  341.             3.14,
  342.             'abc'],
  343.         {
  344.             'abc': 'ABC' },
  345.         (),
  346.         [],
  347.         { }]
  348.     l1 = copy(l)
  349.     print l1 == l
  350.     l1 = map(copy, l)
  351.     print l1 == l
  352.     l1 = deepcopy(l)
  353.     print l1 == l
  354.     
  355.     class C:
  356.         
  357.         def __init__(self, arg = None):
  358.             self.a = 1
  359.             self.arg = arg
  360.             if __name__ == '__main__':
  361.                 import sys as sys
  362.                 file = sys.argv[0]
  363.             else:
  364.                 file = __file__
  365.             self.fp = open(file)
  366.             self.fp.close()
  367.  
  368.         
  369.         def __getstate__(self):
  370.             return {
  371.                 'a': self.a,
  372.                 'arg': self.arg }
  373.  
  374.         
  375.         def __setstate__(self, state):
  376.             for key, value in state.iteritems():
  377.                 setattr(self, key, value)
  378.             
  379.  
  380.         
  381.         def __deepcopy__(self, memo = None):
  382.             new = self.__class__(deepcopy(self.arg, memo))
  383.             new.a = self.a
  384.             return new
  385.  
  386.  
  387.     c = C('argument sketch')
  388.     l.append(c)
  389.     l2 = copy(l)
  390.     print l == l2
  391.     print l
  392.     print l2
  393.     l2 = deepcopy(l)
  394.     print l == l2
  395.     print l
  396.     print l2
  397.     l.append({
  398.         l[1]: l,
  399.         'xyz': l[2] })
  400.     l3 = copy(l)
  401.     import repr as repr
  402.     print map(repr.repr, l)
  403.     print map(repr.repr, l1)
  404.     print map(repr.repr, l2)
  405.     print map(repr.repr, l3)
  406.     l3 = deepcopy(l)
  407.     import repr as repr
  408.     print map(repr.repr, l)
  409.     print map(repr.repr, l1)
  410.     print map(repr.repr, l2)
  411.     print map(repr.repr, l3)
  412.  
  413. if __name__ == '__main__':
  414.     _test()
  415.  
  416.